#include "playpage.h"
#include<QPainter>
#include<QKeyEvent>
#include<QMouseEvent>
#include<QIcon>
#include<QPushButton>
PlayPage::PlayPage(QWidget *parent) : QWidget(parent)
{
    //游戏界面设置
    setFixedSize(700,1000);
    setWindowTitle("飞机大战8.0");
    setWindowIcon(QPixmap(":/tpw/logo.jpeg"));

    //定时器
    timer->start(42);//42ms动一次
    connect(timer,&QTimer::timeout,[=](){
        //每次地图向下移动10
        posY+=10;
        posYY+=10;
        maprecorder++;
        update();//地图更新
        //地图超出游戏界面后重新回到上面
        if(posY>=this->height())
        {
            posY=-1000;
        }
        if(posYY>=this->height())
        {
            posYY=-1000;
        }
        //每次伴随着我方飞机的射击
        p_plane.shoot();
        for(int i=0;i<20;i++)
        {
            if(p_plane.clip[i].bulfree==false)
                 p_plane.clip[i].updatebul();
        }
        if(p_plane.upgrade)
        {
            for(int i=0;i<20;i++)
            {
                if(p_plane.clip2[i].bulfree2==false)
                     p_plane.clip2[i].updatebul2();
            }
            for(int i=0;i<20;i++)
            {
                if(p_plane.clip3[i].bulfree3==false)
                     p_plane.clip3[i].updatebul3();
            }
            if(p_plane.upgrade2)
            {
                for(int i=0;i<20;i++)
                {
                    if(p_plane.clip4[i].bulfree4==false)
                         p_plane.clip4[i].updatebul4();
                }
                for(int i=0;i<20;i++)
                {
                    if(p_plane.clip5[i].bulfree5==false)
                         p_plane.clip5[i].updatebul5();
                }
            }
        }
        //敌机射击
        for(int i=0;i<20;i++)
        {
            if(queue[i].enefree==false)//敌机出战
            {
               queue[i].shoot();
               for(int j=0;j<30;j++)
               {
                   if(queue[i].clip[j].bulfree==false)
                        queue[i].clip[j].updatebul();//当敌机和子弹都不空闲时更新子弹的坐标
               }
            }
            else//
            {
                for(int j=0;j<30;j++)
                {
                    if(queue[i].clip[j].bulfree==false)
                    {
                         queue[i].clip[j].updatebul();//当敌机死掉但子弹仍在场时更新子弹的坐标
                    }
                }
            }
        }
        for(int i=0;i<10;i++)
        {
            if(queue2[i].enefree==false)//敌机出战
            {
               queue2[i].shoot();
               for(int j=0;j<30;j++)
               {

                   if(queue2[i].clip[j].bulfree==false)
                        queue2[i].clip[j].updatebul();//当敌机和子弹都不空闲时更新子弹的坐标
               }
            }
            else
            {
                for(int j=0;j<30;j++)
                {
                    if(queue2[i].clip[j].bulfree==false)
                    {
                         queue2[i].clip[j].updatebul();//当敌机死掉但子弹仍在场时更新子弹的坐标
                    }
                }
            }
        }
        //boss出战与射击
        if(maprecorder>=1150)
            boss.bosfree=false;
            if(boss.bosfree==false)
            {
                boss.bosY+=10;
                if(boss.bosY>=100)
                    boss.bosY=100;
                boss.bosrec.moveTo(boss.bosX,boss.bosY);
                boss.shoot();
                for(int i=0;i<10;i++)
                {
                    if(boss.clip[i].bulfree==false)
                    {
                        boss.clip[i].updatebul();
                    }
                }
            }

        //每次伴随着敌人的出现
        enemyplane();
        for(int i=0;i<20;i++)
        {
            if(queue[i].enefree==false)
                 queue[i].updateene();
        }
        for(int i=0;i<10;i++)
        {
            if(queue2[i].enefree==false)
                 queue2[i].updateene();
        }
        //每次伴随着一遍碰撞检测
        collisionDetection();
        //保护罩
        cover.updatecover();
        cover.coverX=p_plane.planeX-1;
        cover.coverY=p_plane.planeY-1;
    });
     //随机数种子--真随机与伪随机
     srand((unsigned int)time(NULL));
     //游戏页面的暂停与继续按钮
     QPushButton *pause=new QPushButton("暂停",this);
     QPushButton*jixu=new QPushButton("继续",this);
     pause->move(0,40);
     jixu->move(0,40);
     jixu->hide();
     connect(pause,&QPushButton::clicked,[=](){
         timer->stop();
         pause->hide();
         jixu->show();
 });
     connect(jixu,&QPushButton::clicked,[=](){
         if(p_plane.pfree==false)
         timer->start(42);
         jixu->hide();
         pause->show();
     });

     //游戏页面的返回按钮
      QPushButton *back=new QPushButton("返回",this);
      //点击返回，发送信号
      connect(back,&QPushButton::clicked,[=](){

          count=0;
          p_plane.planeX=300;
          p_plane.planeY=900;
          emit sendsignal();
          this->hide();
      });
}
//游戏界面的绘制
void PlayPage::paintEvent(QPaintEvent *)
{

    QPainter painter(this);
    //两张地图背景
    if(maprecorder<1000)
    {
        painter.drawPixmap(0,posY,700,1000,QPixmap(":/tpw/forest.jpeg"));
        painter.drawPixmap(0,posYY,700,1000,QPixmap(":/tpw/forest.jpeg"));
    }
    if(maprecorder>=1000)
    {
        painter.drawPixmap(0,posY,700,1000,QPixmap(":/tpw/night.jpg"));
        painter.drawPixmap(0,posYY,700,1000,QPixmap(":/tpw/night.jpg"));
    }
    if((maprecorder>=950&&maprecorder<970)||(maprecorder>=990&&maprecorder<1100))
    {
        painter.drawPixmap(280,450,140,50,QPixmap(":/tpw/warning.png"));
    }
    //飞机绘制
    if(p_plane.pfree==false)
    painter.drawPixmap(p_plane.planeX,p_plane.planeY,100,100,p_plane.planee);
    //弹夹绘制
    for(int i=0;i<20;i++)//逐一遍历，如果某个子弹不位于空闲状态就画出它来  我方弹夹
    {
        if(p_plane.clip[i].bulfree==false)
           painter.drawPixmap(p_plane.clip[i].bulX,p_plane.clip[i].bulY,30,30,b_bullet.bullett);
    }
    if(p_plane.upgrade)
    {
        for(int i=0;i<20;i++)//逐一遍历，如果某个子弹不位于空闲状态就画出它来  我方弹夹
        {
            if(p_plane.clip2[i].bulfree2==false)
               painter.drawPixmap(p_plane.clip2[i].bul2X,p_plane.clip2[i].bul2Y,30,30,b_bullet.bullett2);
        }
        for(int i=0;i<20;i++)//逐一遍历，如果某个子弹不位于空闲状态就画出它来  我方弹夹
        {
            if(p_plane.clip3[i].bulfree3==false)
               painter.drawPixmap(p_plane.clip3[i].bul3X,p_plane.clip3[i].bul3Y,30,30,b_bullet.bullett3);
        }
        if(p_plane.upgrade2)
        {
            for(int i=0;i<20;i++)//逐一遍历，如果某个子弹不位于空闲状态就画出它来  我方弹夹
            {
                if(p_plane.clip4[i].bulfree4==false)
                   painter.drawPixmap(p_plane.clip4[i].bul4X,p_plane.clip4[i].bul4Y,30,30,b_bullet.bullett4);
            }
            for(int i=0;i<20;i++)//逐一遍历，如果某个子弹不位于空闲状态就画出它来  我方弹夹
            {
                if(p_plane.clip5[i].bulfree5==false)
                   painter.drawPixmap(p_plane.clip5[i].bul5X,p_plane.clip5[i].bul5Y,30,30,b_bullet.bullett5);
            }
        }
    }
    for(int i=0;i<20;i++)//敌机弹夹
    {
        if(queue[i].enefree==false)//若敌机出战
        {
            for(int j=0;j<30;j++)
            {
                if(queue[i].clip[j].bulfree==false)//找到敌机打出的子弹
                    painter.drawPixmap(queue[i].clip[j].bulX,queue[i].clip[j].bulY,30,30,b_bullet_e.bullett);
            }
        }
        //敌机死掉后，它的子弹仍留在了场上
        else
        {
            for(int j=0;j<30;j++)
            {
                if(queue[i].clip[j].bulfree==false)//找到敌机剩下的子弹
                    painter.drawPixmap(queue[i].clip[j].bulX,queue[i].clip[j].bulY,30,30,b_bullet_e.bullett);
            }
        }
    }
    for(int i=0;i<10;i++)//敌机弹夹
    {
        if(queue2[i].enefree==false)//若敌机出战
        {
            for(int j=0;j<30;j++)
            {
                if(queue2[i].clip[j].bulfree==false)//找到敌机打出的子弹
                    painter.drawPixmap(queue2[i].clip[j].bulX,queue2[i].clip[j].bulY,30,30,b_bullet_e.bullett2);
            }
        }
        //敌机死掉后，它的子弹仍留在了场上
        else
        {
            for(int j=0;j<30;j++)
            {
                if(queue2[i].clip[j].bulfree==false)//找到敌机剩下的子弹
                    painter.drawPixmap(queue2[i].clip[j].bulX,queue2[i].clip[j].bulY,30,30,b_bullet_e.bullett2);
            }
        }
    }
    if(boss.bosfree==false)
    {
        for(int i=0;i<10;i++)
        {
            if(boss.clip[i].bulfree==false)
            {
                painter.drawPixmap(boss.clip[i].bulX,boss.clip[i].bulY,50,50,b_bullet_b.bullett);
            }
        }
    }
    //敌人绘制
    for(int i=0;i<20;i++)//逐一遍历，如果某架敌机不位于空闲状态就画出它来
    {
        if(queue[i].enefree==false)
           painter.drawPixmap(queue[i].eneX,queue[i].eneY,100,100,e_enemy.enemyy);
    }
    for(int i=0;i<10;i++)
    {
        if(queue2[i].enefree==false)
           painter.drawPixmap(queue2[i].eneX,queue2[i].eneY,100,100,e_enemy.enemyy2);
    }
        if(boss.bosfree==false)
        {
            painter.drawPixmap(boss.bosX,boss.bosY,500,300,boss.boss);
        }
    //如果我方死了，出现失败画面
    if(p_plane.pfree)
    {
        painter.drawPixmap(100,400,QPixmap(":/tpw/lose.jpg"));
    }
    //如果boss死了，出现胜利画面
    if(boss.bosfree&&maprecorder>=1150)
    {
        painter.drawPixmap(100,200,500,200,QPixmap(":/tpw/win.jpeg"));
    }
    //升级图片绘制
    switch (count)
    {
    case 0:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
    }
    case 1:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,45,50,10,QPixmap(":/tpw/1-1.png"));
        break;
    }
    case 2:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,35,50,20,QPixmap(":/tpw/1-2.png"));
        break;
    }
    case 3:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,25,50,30,QPixmap(":/tpw/1-3.png"));
        break;
    }
    case 4:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,15,50,40,QPixmap(":/tpw/1-4.png"));
        break;
    }
    case 5:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/1-5.png"));
        break;
    }
    case 6:
    {
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/1-5.png"));
        painter.drawPixmap(650,45,50,10,QPixmap(":/tpw/2-1.png"));
        break;
    }
    case 7:
    {
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/1-5.png"));
        painter.drawPixmap(650,35,50,20,QPixmap(":/tpw/2-2.png"));
        break;
    }
    case 8:
    {
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/1-5.png"));
        painter.drawPixmap(650,25,50,30,QPixmap(":/tpw/2-3.png"));
        break;
    }
    case 9:
    {
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/0.png"));
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/1-5.png"));
         painter.drawPixmap(650,15,50,40,QPixmap(":/tpw/2-4.png"));
         break;
    }
    default:
    {
        painter.drawPixmap(600,5,50,50,QPixmap(":/tpw/1-5.png"));
        painter.drawPixmap(650,5,50,50,QPixmap(":/tpw/2-5.png"));
        break;
    }
    }
}
//键盘事件
void PlayPage::keyPressEvent(QKeyEvent *event)
{
    if(count>=5)
    {
        if(event->key()==Qt::Key_Q)
            p_plane.upgrade=true;
    }
    if(count>=10&&p_plane.upgrade==true)
    {
        if(event->key()==Qt::Key_W)
            p_plane.upgrade2=true;
    }

}
//鼠标事件
void PlayPage::mouseMoveEvent(QMouseEvent *event)
{
    p_plane.planeX=event->x()-50;
    p_plane.planeY=event->y()-50;//减去50，让指针指在飞机中间
    p_plane.prec.moveTo(p_plane.planeX,p_plane.planeY);//飞机的矩形框变化，用于碰撞检测
    if(p_plane.planeY<=0)
        p_plane.planeY=0;
    if(p_plane.planeY>=920)
        p_plane.planeY=920;
    if(p_plane.planeX<=0)
        p_plane.planeX=0;
    if(p_plane.planeX>=620)
       p_plane.planeX=620;
}
//敌人的出现
void PlayPage::enemyplane()
{
    if(maprecorder<900||maprecorder>=1100)
    {
    interval2++;
    if(interval2<=25)//每隔25*42ms刷新一次，interval2用于计时卡点。没到时候就return
        return;
    interval2=1;//到时候了重置interval2
    //逐一遍历，若有敌机位于空闲状态就刷新它出来
    for(int i=0;i<20;i++)
    {
        if(queue[i].enefree==true)
        {
            queue[i].eneX=rand()%600;//x坐标为随机数
            queue[i].eneY=-99;//y坐标为负的飞机长度
            queue[i].enefree=false;//刷新出来后飞机不再是空闲状态了
            break;
        }
    }
    for(int i=0;i<10;i++)
    {
        if(queue2[i].enefree==true)
        {
            queue2[i].eneX=rand()%600;//x坐标为随机数
            queue2[i].eneY=-99;//y坐标为负的飞机长度
            queue2[i].enefree=false;//刷新出来后飞机不再是空闲状态了
            break;
        }
    }
    }
}
//碰撞检测
void PlayPage::collisionDetection()
{
    //我方子弹打敌机
    for(int i=0;i<20;i++)//打第一种敌机
    {
        if(queue[i].enefree)//逐一遍历，若敌机是空闲状态continue
            continue;
        for(int j=0;j<20;j++)//第一种子弹打第一种飞机
        {
            if(p_plane.clip[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                continue;
            if(queue[i].erec.intersects(p_plane.clip[j].brec))//非空闲的子弹和敌机的矩形框若有交集
            {
                queue[i].enefree=true;
                p_plane.clip[j].bulfree=true;//重置两者，变为空闲状态
                count++;//击落敌机计数
                if((rand()%500)>250)//击落敌机后50%几率出现急救包
                {
                    for(int k=0;k<20;k++)
                    {
                        if(help[k].helpfree)
                        {
                            help[k].helpfree=false;
                            help[k].helpX=queue[i].eneX;
                            help[k].helpY=queue[i].eneY;
                            break;
                        }
                    }
                }
            }
        }
        if(p_plane.upgrade)//子弹更新到第二种形态后
        {
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip2[j].bulfree2)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue[i].erec.intersects(p_plane.clip2[j].brec2))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue[i].enefree=true;
                    p_plane.clip2[j].bulfree2=true;//重置两者，变为空闲状态
                    count++;
                    if((rand()%500)>250)
                    {
                        for(int k=0;k<20;k++)
                        {
                            if(help[k].helpfree)
                            {
                                help[k].helpfree=false;
                                help[k].helpX=queue[i].eneX;
                                help[k].helpY=queue[i].eneY;
                                break;
                            }
                        }
                    }
                }
            }
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip3[j].bulfree3)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue[i].erec.intersects(p_plane.clip3[j].brec3))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue[i].enefree=true;
                    p_plane.clip3[j].bulfree3=true;//重置两者，变为空闲状态
                    count++;
                    if((rand()%500)>250)
                    {
                        for(int k=0;k<20;k++)
                        {
                            if(help[k].helpfree)
                            {
                                help[k].helpfree=false;
                                help[k].helpX=queue[i].eneX;
                                help[k].helpY=queue[i].eneY;
                                break;
                            }
                        }
                    }
                }
            }
        }
        if(p_plane.upgrade2)//子弹更新到第三种形态后
        {
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip4[j].bulfree4)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue[i].erec.intersects(p_plane.clip4[j].brec4))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue[i].enefree=true;
                    p_plane.clip4[j].bulfree4=true;//重置两者，变为空闲状态
                    count++;
                    if((rand()%500)>250)
                    {
                        for(int k=0;k<20;k++)
                        {
                            if(help[k].helpfree)
                            {
                                help[k].helpfree=false;
                                help[k].helpX=queue[i].eneX;
                                help[k].helpY=queue[i].eneY;
                                break;
                            }
                        }
                    }
                }
            }
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip5[j].bulfree5)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue[i].erec.intersects(p_plane.clip5[j].brec5))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue[i].enefree=true;
                    p_plane.clip5[j].bulfree5=true;//重置两者，变为空闲状态
                    count++;
                    if((rand()%500)>250)
                    {
                        for(int k=0;k<20;k++)
                        {
                            if(help[k].helpfree)
                            {
                                help[k].helpfree=false;
                                help[k].helpX=queue[i].eneX;
                                help[k].helpY=queue[i].eneY;
                                break;
                            }
                        }
                    }
                }
            }
        }

    }
    for(int i=0;i<10;i++)//打第二种敌机
    {
        if(queue2[i].enefree)//逐一遍历，若敌机是空闲状态continue
            continue;
        for(int j=0;j<20;j++)
        {
            if(p_plane.clip[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                continue;
            if(queue2[i].erec.intersects(p_plane.clip[j].brec))//非空闲的子弹和敌机的矩形框若有交集
            {
                queue2[i].interval4++;
                p_plane.clip[j].bulfree=true;//不要漏了这一句，否则子弹不会消失
                if(queue2[i].interval4>=2)
                {
                    queue2[i].interval4=0;
                    queue2[i].enefree=true;//重置敌机，变为空闲状态
                    count++;
                    if((rand()%500)>250)
                    {
                        for(int k=0;k<20;k++)
                        {
                            if(help[k].helpfree)
                            {
                                help[k].helpfree=false;
                                help[k].helpX=queue[i].eneX;
                                help[k].helpY=queue[i].eneY;
                                break;
                            }
                        }
                    }
                }
            }
        }
        if(p_plane.upgrade)
        {
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip2[j].bulfree2)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue2[i].erec.intersects(p_plane.clip2[j].brec2))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue2[i].interval4++;
                    p_plane.clip2[j].bulfree2=true;//不要漏了这一句，否则子弹不会消失
                    if(queue2[i].interval4>=2)
                    {
                        queue2[i].interval4=0;
                        queue2[i].enefree=true;//重置敌机，变为空闲状态
                        count++;
                        if((rand()%500)>250)
                        {
                            for(int k=0;k<20;k++)
                            {
                                if(help[k].helpfree)
                                {
                                    help[k].helpfree=false;
                                    help[k].helpX=queue[i].eneX;
                                    help[k].helpY=queue[i].eneY;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip3[j].bulfree3)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue2[i].erec.intersects(p_plane.clip3[j].brec3))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue2[i].interval4++;
                    p_plane.clip3[j].bulfree3=true;//不要漏了这一句，否则子弹不会消失
                    if(queue2[i].interval4>=2)
                    {
                        queue2[i].interval4=0;
                        queue2[i].enefree=true;//重置敌机，变为空闲状态
                        count++;
                        if((rand()%500)>250)
                        {
                            for(int k=0;k<20;k++)
                            {
                                if(help[k].helpfree)
                                {
                                    help[k].helpfree=false;
                                    help[k].helpX=queue[i].eneX;
                                    help[k].helpY=queue[i].eneY;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
        if(p_plane.upgrade2)
        {
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip4[j].bulfree4)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue2[i].erec.intersects(p_plane.clip4[j].brec4))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue2[i].interval4++;
                    p_plane.clip4[j].bulfree4=true;//不要漏了这一句，否则子弹不会消失
                    if(queue2[i].interval4>=2)
                    {
                        queue2[i].interval4=0;
                        queue2[i].enefree=true;//重置敌机，变为空闲状态
                        count++;
                        if((rand()%500)>250)
                        {
                            for(int k=0;k<20;k++)
                            {
                                if(help[k].helpfree)
                                {
                                    help[k].helpfree=false;
                                    help[k].helpX=queue[i].eneX;
                                    help[k].helpY=queue[i].eneY;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            for(int j=0;j<20;j++)
            {
                if(p_plane.clip5[j].bulfree5)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(queue2[i].erec.intersects(p_plane.clip5[j].brec5))//非空闲的子弹和敌机的矩形框若有交集
                {
                    queue2[i].interval4++;
                    p_plane.clip5[j].bulfree5=true;//不要漏了这一句，否则子弹不会消失
                    if(queue2[i].interval4>=2)
                    {
                        queue2[i].interval4=0;
                        queue2[i].enefree=true;//重置敌机，变为空闲状态
                        count++;
                        if((rand()%500)>250)
                        {
                            for(int k=0;k<20;k++)
                            {
                                if(help[k].helpfree)
                                {
                                    help[k].helpfree=false;
                                    help[k].helpX=queue[i].eneX;
                                    help[k].helpY=queue[i].eneY;
                                    break;
                                }
                            }
                        }
                    }
                }
            }

        }
    }
     if(boss.bosfree==false)//打boss
        {
         for(int j=0;j<20;j++)
        {
            if(p_plane.clip[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                continue;
            if(boss.bosrec.intersects(p_plane.clip[j].brec))//非空闲的子弹和敌机的矩形框若有交集
            {
                boss.interval6++;
                p_plane.clip[j].bulfree=true;
                if(boss.interval6>=50)
                {
                    boss.bosfree=true;
                    timer->stop();
                }

            }
         }
         if(p_plane.upgrade)
         {
             for(int j=0;j<20;j++)
            {
                if(p_plane.clip2[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(boss.bosrec.intersects(p_plane.clip2[j].brec))//非空闲的子弹和敌机的矩形框若有交集
                {
                    boss.interval6++;
                    p_plane.clip2[j].bulfree=true;
                    if(boss.interval6>=50)
                    {
                        boss.bosfree=true;
                        timer->stop();
                    }

                }
             }
             for(int j=0;j<20;j++)
            {
                if(p_plane.clip3[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                    continue;
                if(boss.bosrec.intersects(p_plane.clip3[j].brec))//非空闲的子弹和敌机的矩形框若有交集
                {
                    boss.interval6++;
                    p_plane.clip3[j].bulfree=true;
                    if(boss.interval6>=50)
                    {
                        boss.bosfree=true;
                        timer->stop();
                    }

                }
             }
             if(p_plane.upgrade2)
             {
                 for(int j=0;j<20;j++)
                {
                    if(p_plane.clip4[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                        continue;
                    if(boss.bosrec.intersects(p_plane.clip4[j].brec))//非空闲的子弹和敌机的矩形框若有交集
                    {
                        boss.interval6++;
                        p_plane.clip4[j].bulfree=true;
                        if(boss.interval6>=50)
                        {
                            boss.bosfree=true;
                            timer->stop();
                        }

                    }
                 }
                 for(int j=0;j<20;j++)
                {
                    if(p_plane.clip5[j].bulfree)//逐一遍历，若子弹处于空闲状态continue
                        continue;
                    if(boss.bosrec.intersects(p_plane.clip5[j].brec))//非空闲的子弹和敌机的矩形框若有交集
                    {
                        boss.interval6++;
                        p_plane.clip5[j].bulfree=true;
                        if(boss.interval6>=50)
                        {
                            boss.bosfree=true;
                            timer->stop();
                        }

                    }
                 }
             }
         }
        }
    //敌机子弹打我方
         if(cover.use)//有防护罩时
         {
             for(int i=0;i<20;i++)
             {
                     for(int j=0;j<30;j++)
                     {
                         if(queue[i].clip[j].bulfree)//逐一遍历，若敌机子弹是空闲状态continue  不管敌机是否出现，只要子弹在场就行
                             continue;
                         if(cover.coverrec.intersects(queue[i].clip[j].brec))//非空闲的子弹和我方的矩形框若有交集
                         {
                              queue[i].clip[j].bulfree=true;
                         }
                     }
             }
             for(int i=0;i<20;i++)
             {
                     for(int j=0;j<30;j++)
                     {
                         if(queue2[i].clip[j].bulfree)//逐一遍历，若敌机子弹是空闲状态continue  不管敌机是否出现，只要子弹在场就行
                             continue;
                         if(cover.coverrec.intersects(queue2[i].clip[j].brec))//非空闲的子弹和我方的矩形框若有交集
                         {
                              queue2[i].clip[j].bulfree=true;
                         }
                     }
             }
             if(boss.bosfree==false)
             {
             for(int i=0;i<10;i++)
             {
                 if(boss.clip[i].bulfree==false)
                 {
                     if(cover.coverrec.intersects(boss.clip[i].brec))
                         boss.clip[i].bulfree=true;
                 }
             }
             }
         }
         if(cover.use==false)
         {
         for(int i=0;i<20;i++)
         {
                 for(int j=0;j<30;j++)
                 {
                     if(queue[i].clip[j].bulfree)//逐一遍历，若敌机子弹是空闲状态continue  不管敌机是否出现，只要子弹在场就行
                         continue;
                     if(p_plane.prec.intersects(queue[i].clip[j].brec))//非空闲的子弹和我方的矩形框若有交集
                         {
                             queue[i].clip[j].bulfree=true;
                             p_plane.pfree=true;
                             timer->stop();//碰到子弹暂停页面
                         }
                     }
             }
         for(int i=0;i<10;i++)
         {
                 for(int j=0;j<30;j++)
                 {
                     if(queue2[i].clip[j].bulfree)//逐一遍历，若敌机子弹是空闲状态continue  不管敌机是否出现，只要子弹在场就行
                         continue;
                     if(p_plane.prec.intersects(queue2[i].clip[j].brec))//非空闲的子弹和我方的矩形框若有交集
                         {
                             queue2[i].clip[j].bulfree=true;
                             p_plane.pfree=true;
                             timer->stop();//碰到子弹暂停页面
                         }
                     }

             }
         if(boss.bosfree==false)
         {
         for(int j=0;j<30;j++)
         {
             if(boss.clip[j].bulfree)//逐一遍历，若敌机子弹是空闲状态continue  不管敌机是否出现，只要子弹在场就行
                 continue;
             if(p_plane.prec.intersects(boss.clip[j].brec))//非空闲的子弹和我方的矩形框若有交集
                 {
                     boss.clip[j].bulfree=true;
                     p_plane.pfree=true;
                     timer->stop();//碰到子弹暂停页面
                 }
             }
         }
     }
         //敌机和我方相撞
         if(cover.use)
         {
             for(int i=0;i<20;i++)
             {
                 if(queue[i].enefree==false)//敌机非空闲
                 {
                     if(cover.coverrec.intersects(queue[i].erec))
                     {
                         queue[i].enefree=true;
                     }
                 }
             }
             for(int i=0;i<20;i++)
             {
                 if(queue2[i].enefree==false)//敌机非空闲
                 {
                     if(cover.coverrec.intersects(queue2[i].erec))
                     {
                         queue2[i].enefree=true;
                     }
                 }
             }
         }
         if(cover.use==false)
         {
         for(int i=0;i<20;i++)
         {
             if(queue[i].enefree==false)//敌机非空闲
             {
                 if(p_plane.prec.intersects(queue[i].erec))
                 {
                     queue[i].enefree=true;
                     p_plane.pfree=true;
                     timer->stop();//碰到后暂停页面
                 }
             }
         }
         for(int i=0;i<10;i++)
         {
             if(queue2[i].enefree==false)//敌机非空闲
             {
                 if(p_plane.prec.intersects(queue2[i].erec))
                 {
                     queue2[i].enefree=true;
                     p_plane.pfree=true;
                     timer->stop();//碰到后暂停页面
                 }
             }
         }
          if(boss.bosfree==false)
             {
                 if(p_plane.prec.intersects(boss.bosrec))
                 {
                     boss.bosfree=true;
                     p_plane.pfree=true;
                     timer->stop();//碰到后暂停页面
                 }
             }
         }
}


//地图的初始位置
int PlayPage::posY=0;
int PlayPage::posYY=-1000;
//interval2初始化
int PlayPage::interval2=1;
int PlayPage::count=0;
